{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--BOOK_INFORMATION-->\n",
    "<img align=\"left\" style=\"padding-right:10px;\" src=\"figures/PDSH-cover-small.png\">\n",
    "\n",
    "*This notebook contains an excerpt from the [Python Data Science Handbook](http://shop.oreilly.com/product/0636920034919.do) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/PythonDataScienceHandbook).*\n",
    "\n",
    "*The text is released under the [CC-BY-NC-ND license](https://creativecommons.org/licenses/by-nc-nd/3.0/us/legalcode), and code is released under the [MIT license](https://opensource.org/licenses/MIT). If you find this content useful, please consider supporting the work by [buying the book](http://shop.oreilly.com/product/0636920034919.do)!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Introducing Scikit-Learn](05.02-Introducing-Scikit-Learn.ipynb) | [Contents](Index.ipynb) | [Feature Engineering](05.04-Feature-Engineering.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/05.03-Hyperparameters-and-Model-Validation.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hyperparameters and Model Validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In the previous section, we saw the basic recipe for applying a supervised machine learning model:\n",
    "\n",
    "1. Choose a class of model\n",
    "2. Choose model hyperparameters\n",
    "3. Fit the model to the training data\n",
    "4. Use the model to predict labels for new data\n",
    "\n",
    "The first two pieces of this—the choice of model and choice of hyperparameters—are perhaps the most important part of using these tools and techniques effectively.\n",
    "In order to make an informed choice, we need a way to *validate* that our model and our hyperparameters are a good fit to the data.\n",
    "While this may sound simple, there are some pitfalls that you must avoid to do this effectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thinking about Model Validation\n",
    "\n",
    "In principle, model validation is very simple: after choosing a model and its hyperparameters, we can estimate how effective it is by applying it to some of the training data and comparing the prediction to the known value.\n",
    "\n",
    "The following sections first show a naive approach to model validation and why it\n",
    "fails, before exploring the use of holdout sets and cross-validation for more robust\n",
    "model evaluation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model validation the wrong way\n",
    "\n",
    "Let's demonstrate the naive approach to validation using the Iris data, which we saw in the previous section.\n",
    "We will start by loading the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "y = iris.target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we choose a model and hyperparameters. Here we'll use a *k*-neighbors classifier with ``n_neighbors=1``.\n",
    "This is a very simple and intuitive model that says \"the label of an unknown point is the same as the label of its closest training point:\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "model = KNeighborsClassifier(n_neighbors=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we train the model, and use it to predict labels for data we already know:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(X, y)\n",
    "y_model = model.predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we compute the fraction of correctly labeled points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "accuracy_score(y, y_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see an accuracy score of 1.0, which indicates that 100% of points were correctly labeled by our model!\n",
    "But is this truly measuring the expected accuracy? Have we really come upon a model that we expect to be correct 100% of the time?\n",
    "\n",
    "As you may have gathered, the answer is no.\n",
    "In fact, this approach contains a fundamental flaw: *it trains and evaluates the model on the same data*.\n",
    "Furthermore, the nearest neighbor model is an *instance-based* estimator that simply stores the training data, and predicts labels by comparing new data to these stored points: except in contrived cases, it will get 100% accuracy *every time!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model validation the right way: Holdout sets\n",
    "\n",
    "So what can be done?\n",
    "A better sense of a model's performance can be found using what's known as a *holdout set*: that is, we hold back some subset of the data from the training of the model, and then use this holdout set to check the model performance.\n",
    "This splitting can be done using the ``train_test_split`` utility in Scikit-Learn:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\KZCF\\Anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9066666666666666"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#from sklearn.cross_validation import train_test_split\n",
    "from sklearn.model_selection import train_test_split\n",
    " \n",
    "# split the data with 50% in each set\n",
    "X1, X2, y1, y2 = train_test_split(X, y, random_state=0,\n",
    "                                  train_size=0.5)\n",
    "\n",
    "# fit the model on one set of data\n",
    "model.fit(X1, y1)\n",
    "\n",
    "# evaluate the model on the second set of data\n",
    "y2_model = model.predict(X2)\n",
    "accuracy_score(y2, y2_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see here a more reasonable result: the nearest-neighbor classifier is about 90% accurate on this hold-out set.\n",
    "The hold-out set is similar to unknown data, because the model has not \"seen\" it before."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model validation via cross-validation\n",
    "\n",
    "One disadvantage of using a holdout set for model validation is that we have lost a portion of our data to the model training.\n",
    "In the above case, half the dataset does not contribute to the training of the model!\n",
    "This is not optimal, and can cause problems – especially if the initial set of training data is small.\n",
    "\n",
    "One way to address this is to use *cross-validation*; that is, to do a sequence of fits where each subset of the data is used both as a training set and as a validation set.\n",
    "Visually, it might look something like this:\n",
    "\n",
    "![](figures/05.03-2-fold-CV.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#2-Fold-Cross-Validation)\n",
    "\n",
    "Here we do two validation trials, alternately using each half of the data as a holdout set.\n",
    "Using the split data from before, we could implement it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.96, 0.9066666666666666)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y2_model = model.fit(X1, y1).predict(X2)\n",
    "y1_model = model.fit(X2, y2).predict(X1)\n",
    "accuracy_score(y1, y1_model), accuracy_score(y2, y2_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What comes out are two accuracy scores, which we could combine (by, say, taking the mean) to get a better measure of the global model performance.\n",
    "This particular form of cross-validation is a *two-fold cross-validation*—that is, one in which we have split the data into two sets and used each in turn as a validation set.\n",
    "\n",
    "We could expand on this idea to use even more trials, and more folds in the data—for example, here is a visual depiction of five-fold cross-validation:\n",
    "\n",
    "![](figures/05.03-5-fold-CV.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#5-Fold-Cross-Validation)\n",
    "\n",
    "Here we split the data into five groups, and use each of them in turn to evaluate the model fit on the other 4/5 of the data.\n",
    "This would be rather tedious to do by hand, and so we can use Scikit-Learn's ``cross_val_score`` convenience routine to do it succinctly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.96666667, 0.96666667, 0.93333333, 0.93333333, 1.        ])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(model, X, y, cv=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeating the validation across different subsets of the data gives us an even better idea of the performance of the algorithm.\n",
    "\n",
    "Scikit-Learn implements a number of useful cross-validation schemes that are useful in particular situations; these are implemented via iterators in the ``cross_validation`` module.\n",
    "For example, we might wish to go to the extreme case in which our number of folds is equal to the number of data points: that is, we train on all points but one in each trial.\n",
    "This type of cross-validation is known as *leave-one-out* cross validation, and can be used as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 0., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import LeaveOneOut\n",
    "#LeaveOneOut().split(X)\n",
    "scores = cross_val_score(model, X, y, cv=LeaveOneOut().split(X))\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we have 150 samples, the leave one out cross-validation yields scores for 150 trials, and the score indicates either successful (1.0) or unsuccessful (0.0) prediction.\n",
    "Taking the mean of these gives an estimate of the error rate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.96"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other cross-validation schemes can be used similarly.\n",
    "For a description of what is available in Scikit-Learn, use IPython to explore the ``sklearn.cross_validation`` submodule, or take a look at Scikit-Learn's online [cross-validation documentation](http://scikit-learn.org/stable/modules/cross_validation.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selecting the Best Model\n",
    "\n",
    "Now that we've seen the basics of validation and cross-validation, we will go into a litte more depth regarding model selection and selection of hyperparameters.\n",
    "These issues are some of the most important aspects of the practice of machine learning, and I find that this information is often glossed over in introductory machine learning tutorials.\n",
    "\n",
    "Of core importance is the following question: *if our estimator is underperforming, how should we move forward?*\n",
    "There are several possible answers:\n",
    "\n",
    "- Use a more complicated/more flexible model\n",
    "- Use a less complicated/less flexible model\n",
    "- Gather more training samples\n",
    "- Gather more data to add features to each sample\n",
    "\n",
    "The answer to this question is often counter-intuitive.\n",
    "In particular, sometimes using a more complicated model will give worse results, and adding more training samples may not improve your results!\n",
    "The ability to determine what steps will improve your model is what separates the successful machine learning practitioners from the unsuccessful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Bias-variance trade-off\n",
    "\n",
    "Fundamentally, the question of \"the best model\" is about finding a sweet spot in the tradeoff between *bias* and *variance*.\n",
    "Consider the following figure, which presents two regression fits to the same dataset:\n",
    "\n",
    "![](figures/05.03-bias-variance.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#Bias-Variance-Tradeoff)\n",
    "\n",
    "It is clear that neither of these models is a particularly good fit to the data, but they fail in different ways.\n",
    "\n",
    "The model on the left attempts to find a straight-line fit through the data.\n",
    "Because the data are intrinsically more complicated than a straight line, the straight-line model will never be able to describe this dataset well.\n",
    "Such a model is said to *underfit* the data: that is, it does not have enough model flexibility to suitably account for all the features in the data; another way of saying this is that the model has high *bias*.\n",
    "\n",
    "The model on the right attempts to fit a high-order polynomial through the data.\n",
    "Here the model fit has enough flexibility to nearly perfectly account for the fine features in the data, but even though it very accurately describes the training data, its precise form seems to be more reflective of the particular noise properties of the data rather than the intrinsic properties of whatever process generated that data.\n",
    "Such a model is said to *overfit* the data: that is, it has so much model flexibility that the model ends up accounting for random errors as well as the underlying data distribution; another way of saying this is that the model has high *variance*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To look at this in another light, consider what happens if we use these two models to predict the y-value for some new data.\n",
    "In the following diagrams, the red/lighter points indicate data that is omitted from the training set:\n",
    "\n",
    "![](figures/05.03-bias-variance-2.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#Bias-Variance-Tradeoff-Metrics)\n",
    "\n",
    "The score here is the $R^2$ score, or [coefficient of determination](https://en.wikipedia.org/wiki/Coefficient_of_determination), which measures how well a model performs relative to a simple mean of the target values. $R^2=1$ indicates a perfect match, $R^2=0$ indicates the model does no better than simply taking the mean of the data, and negative values mean even worse models.\n",
    "From the scores associated with these two models, we can make an observation that holds more generally:\n",
    "\n",
    "- For high-bias models, the performance of the model on the validation set is similar to the performance on the training set.\n",
    "- For high-variance models, the performance of the model on the validation set is far worse than the performance on the training set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we imagine that we have some ability to tune the model complexity, we would expect the training score and validation score to behave as illustrated in the following figure:\n",
    "\n",
    "![](figures/05.03-validation-curve.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#Validation-Curve)\n",
    "\n",
    "The diagram shown here is often called a *validation curve*, and we see the following essential features:\n",
    "\n",
    "- The training score is everywhere higher than the validation score. This is generally the case: the model will be a better fit to data it has seen than to data it has not seen.\n",
    "- For very low model complexity (a high-bias model), the training data is under-fit, which means that the model is a poor predictor both for the training data and for any previously unseen data.\n",
    "- For very high model complexity (a high-variance model), the training data is over-fit, which means that the model predicts the training data very well, but fails for any previously unseen data.\n",
    "- For some intermediate value, the validation curve has a maximum. This level of complexity indicates a suitable trade-off between bias and variance.\n",
    "\n",
    "The means of tuning the model complexity varies from model to model; when we discuss individual models in depth in later sections, we will see how each model allows for such tuning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Validation curves in Scikit-Learn\n",
    "\n",
    "Let's look at an example of using cross-validation to compute the validation curve for a class of models.\n",
    "Here we will use a *polynomial regression* model: this is a generalized linear model in which the degree of the polynomial is a tunable parameter.\n",
    "For example, a degree-1 polynomial fits a straight line to the data; for model parameters $a$ and $b$:\n",
    "\n",
    "$$\n",
    "y = ax + b\n",
    "$$\n",
    "\n",
    "A degree-3 polynomial fits a cubic curve to the data; for model parameters $a, b, c, d$:\n",
    "\n",
    "$$\n",
    "y = ax^3 + bx^2 + cx + d\n",
    "$$\n",
    "\n",
    "We can generalize this to any number of polynomial features.\n",
    "In Scikit-Learn, we can implement this with a simple linear regression combined with the polynomial preprocessor.\n",
    "We will use a *pipeline* to string these operations together (we will discuss polynomial features and pipelines more fully in [Feature Engineering](05.04-Feature-Engineering.ipynb)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.pipeline import make_pipeline\n",
    "\n",
    "def PolynomialRegression(degree=2, **kwargs):\n",
    "    return make_pipeline(PolynomialFeatures(degree),\n",
    "                         LinearRegression(**kwargs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Now let's create some data to which we will fit our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def make_data(N, err=1.0, rseed=1):\n",
    "    # randomly sample the data\n",
    "    rng = np.random.RandomState(rseed)\n",
    "    X = rng.rand(N, 1) ** 2\n",
    "    y = 10 - 1. / (X.ravel() + 0.1)\n",
    "    if err > 0:\n",
    "        y += err * rng.randn(N)\n",
    "    return X, y\n",
    "\n",
    "X, y = make_data(40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now visualize our data, along with polynomial fits of several degrees:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set()  # plot formatting\n",
    "\n",
    "X_test = np.linspace(-0.1, 1.1, 500)[:, None]\n",
    "\n",
    "plt.scatter(X.ravel(), y, color='black')\n",
    "axis = plt.axis()\n",
    "for degree in [1, 3, 5]:\n",
    "    y_test = PolynomialRegression(degree).fit(X, y).predict(X_test)\n",
    "    plt.plot(X_test.ravel(), y_test, label='degree={0}'.format(degree))\n",
    "plt.xlim(-0.1, 1.0)\n",
    "plt.ylim(-2, 12)\n",
    "plt.legend(loc='best');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The knob controlling model complexity in this case is the degree of the polynomial, which can be any non-negative integer.\n",
    "A useful question to answer is this: what degree of polynomial provides a suitable trade-off between bias (under-fitting) and variance (over-fitting)?\n",
    "\n",
    "We can make progress in this by visualizing the validation curve for this particular data and model; this can be done straightforwardly using the ``validation_curve`` convenience routine provided by Scikit-Learn.\n",
    "Given a model, data, parameter name, and a range to explore, this function will automatically compute both the training score and validation score across the range:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(21, 7)\n",
      "(21, 7)\n",
      "[0.         0.72060505 0.8966661  0.93273606 0.94641559 0.94706837\n",
      " 0.94928043 0.95034312 0.95126473 0.9527462  0.95316414 0.95410179\n",
      " 0.95812976 0.9604493  0.96155007 0.9618062  0.96182216 0.96184622\n",
      " 0.96687087 0.96784028 0.96779683]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import validation_curve\n",
    "degree = np.arange(0, 21)\n",
    "train_score, val_score = validation_curve(PolynomialRegression(), X, y,\n",
    "                                          'polynomialfeatures__degree', degree, cv=7)\n",
    "print(train_score.shape)\n",
    "print(val_score.shape)\n",
    "print(np.median(train_score, 1))\n",
    "plt.plot(degree, np.median(train_score, 1), color='blue', label='training score')\n",
    "plt.plot(degree, np.median(val_score, 1), color='red', label='validation score')\n",
    "plt.legend(loc='best')\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel('degree')\n",
    "plt.ylabel('score');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows precisely the qualitative behavior we expect: the training score is everywhere higher than the validation score; the training score is monotonically improving with increased model complexity; and the validation score reaches a maximum before dropping off as the model becomes over-fit.\n",
    "\n",
    "From the validation curve, we can read-off that the optimal trade-off between bias and variance is found for a third-order polynomial; we can compute and display this fit over the original data as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X.ravel(), y)\n",
    "lim = plt.axis()\n",
    "y_test = PolynomialRegression(3).fit(X, y).predict(X_test)\n",
    "plt.plot(X_test.ravel(), y_test);\n",
    "plt.axis(lim);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that finding this optimal model did not actually require us to compute the training score, but examining the relationship between the training score and validation score can give us useful insight into the performance of the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Curves\n",
    "\n",
    "One important aspect of model complexity is that the optimal model will generally depend on the size of your training data.\n",
    "For example, let's generate a new dataset with a factor of five more points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X2, y2 = make_data(200)\n",
    "plt.scatter(X2.ravel(), y2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will duplicate the preceding code to plot the validation curve for this larger dataset; for reference let's over-plot the previous results as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "degree = np.arange(21)\n",
    "train_score2, val_score2 = validation_curve(PolynomialRegression(), X2, y2,\n",
    "                                            'polynomialfeatures__degree', degree, cv=7)\n",
    "\n",
    "plt.plot(degree, np.median(train_score2, 1), color='blue', label='training score')\n",
    "plt.plot(degree, np.median(val_score2, 1), color='red', label='validation score')\n",
    "plt.plot(degree, np.median(train_score, 1), color='blue', alpha=0.3, linestyle='dashed')\n",
    "plt.plot(degree, np.median(val_score, 1), color='red', alpha=0.3, linestyle='dashed')\n",
    "plt.legend(loc='lower center')\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel('degree')\n",
    "plt.ylabel('score');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solid lines show the new results, while the fainter dashed lines show the results of the previous smaller dataset.\n",
    "It is clear from the validation curve that the larger dataset can support a much more complicated model: the peak here is probably around a degree of 6, but even a degree-20 model is not seriously over-fitting the data—the validation and training scores remain very close.\n",
    "\n",
    "Thus we see that the behavior of the validation curve has not one but two important inputs: the model complexity and the number of training points.\n",
    "It is often useful to to explore the behavior of the model as a function of the number of training points, which we can do by using increasingly larger subsets of the data to fit our model.\n",
    "A plot of the training/validation score with respect to the size of the training set is known as a *learning curve.*\n",
    "\n",
    "The general behavior we would expect from a learning curve is this:\n",
    "\n",
    "- A model of a given complexity will *overfit* a small dataset: this means the training score will be relatively high, while the validation score will be relatively low.\n",
    "- A model of a given complexity will *underfit* a large dataset: this means that the training score will decrease, but the validation score will increase.\n",
    "- A model will never, except by chance, give a better score to the validation set than the training set: this means the curves should keep getting closer together but never cross.\n",
    "\n",
    "With these features in mind, we would expect a learning curve to look qualitatively like that shown in the following figure:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/05.03-learning-curve.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#Learning-Curve)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The notable feature of the learning curve is the convergence to a particular score as the number of training samples grows.\n",
    "In particular, once you have enough points that a particular model has converged, *adding more training data will not help you!*\n",
    "The only way to increase model performance in this case is to use another (often more complex) model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning curves in Scikit-Learn\n",
    "\n",
    "Scikit-Learn offers a convenient utility for computing such learning curves from your models; here we will compute a learning curve for our original dataset with a second-order polynomial model and a ninth-order polynomial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33\n",
      " 34]\n",
      "[10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33\n",
      " 34]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import learning_curve\n",
    "\n",
    "fig, ax = plt.subplots(1, 2, figsize=(16, 6))\n",
    "fig.subplots_adjust(left=0.0625, right=0.95, wspace=0.1)\n",
    "\n",
    "for i, degree in enumerate([2, 9]):\n",
    "    N, train_lc, val_lc = learning_curve(PolynomialRegression(degree),\n",
    "                                         X, y, cv=7,\n",
    "                                         train_sizes=np.linspace(0.3, 1, 25))\n",
    "    print(N)\n",
    "    #print(N.shape),    print(train_lc.shape),    print(val_lc.shape)\n",
    "\n",
    "    ax[i].plot(N, np.mean(train_lc, 1), color='blue', label='training score')\n",
    "    ax[i].plot(N, np.mean(val_lc, 1), color='red', label='validation score')\n",
    "    ax[i].hlines(np.mean([train_lc[-1], val_lc[-1]]), N[0], N[-1],\n",
    "                 color='gray', linestyle='dashed')\n",
    "\n",
    "    ax[i].set_ylim(0, 1)\n",
    "    ax[i].set_xlim(N[0], N[-1])\n",
    "    ax[i].set_xlabel('training size')\n",
    "    ax[i].set_ylabel('score')\n",
    "    ax[i].set_title('degree = {0}'.format(degree), size=14)\n",
    "    ax[i].legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a valuable diagnostic, because it gives us a visual depiction of how our model responds to increasing training data.\n",
    "In particular, when your learning curve has already converged (i.e., when the training and validation curves are already close to each other) *adding more training data will not significantly improve the fit!*\n",
    "This situation is seen in the left panel, with the learning curve for the degree-2 model.\n",
    "\n",
    "The only way to increase the converged score is to use a different (usually more complicated) model.\n",
    "We see this in the right panel: by moving to a much more complicated model, we increase the score of convergence (indicated by the dashed line), but at the expense of higher model variance (indicated by the difference between the training and validation scores).\n",
    "If we were to add even more data points, the learning curve for the more complicated model would eventually converge.\n",
    "\n",
    "Plotting a learning curve for your particular choice of model and dataset can help you to make this type of decision about how to move forward in improving your analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validation in Practice: Grid Search\n",
    "\n",
    "The preceding discussion is meant to give you some intuition into the trade-off between bias and variance, and its dependence on model complexity and training set size.\n",
    "In practice, models generally have more than one knob to turn, and thus plots of validation and learning curves change from lines to multi-dimensional surfaces.\n",
    "In these cases, such visualizations are difficult and we would rather simply find the particular model that maximizes the validation score.\n",
    "\n",
    "Scikit-Learn provides automated tools to do this in the grid search module.\n",
    "Here is an example of using grid search to find the optimal polynomial model.\n",
    "We will explore a three-dimensional grid of model features; namely the polynomial degree, the flag telling us whether to fit the intercept, and the flag telling us whether to normalize the problem.\n",
    "This can be set up using Scikit-Learn's ``GridSearchCV`` meta-estimator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "param_grid = {'polynomialfeatures__degree': np.arange(21),\n",
    "              'linearregression__fit_intercept': [True, False],\n",
    "              'linearregression__normalize': [True, False]}\n",
    "\n",
    "grid = GridSearchCV(PolynomialRegression(), param_grid, cv=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that like a normal estimator, this has not yet been applied to any data.\n",
    "Calling the ``fit()`` method will fit the model at each grid point, keeping track of the scores along the way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\KZCF\\Anaconda3\\lib\\site-packages\\sklearn\\model_selection\\_search.py:841: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "grid.fit(X, y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that this is fit, we can ask for the best parameters as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'linearregression__fit_intercept': False,\n",
       " 'linearregression__normalize': True,\n",
       " 'polynomialfeatures__degree': 4}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, if we wish, we can use the best model and show the fit to our data using code from before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\KZCF\\Anaconda3\\lib\\site-packages\\matplotlib\\pyplot.py:3361: MatplotlibDeprecationWarning: The 'hold' keyword argument is deprecated since 2.0.\n",
      "  mplDeprecation)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = grid.best_estimator_\n",
    "\n",
    "plt.scatter(X.ravel(), y)\n",
    "lim = plt.axis()\n",
    "y_test = model.fit(X, y).predict(X_test)\n",
    "plt.plot(X_test.ravel(), y_test, hold=True);\n",
    "plt.axis(lim);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The grid search provides many more options, including the ability to specify a custom scoring function, to parallelize the computations, to do randomized searches, and more.\n",
    "For information, see the examples in [In-Depth: Kernel Density Estimation](05.13-Kernel-Density-Estimation.ipynb) and [Feature Engineering: Working with Images](05.14-Image-Features.ipynb), or refer to Scikit-Learn's [grid search documentation](http://Scikit-Learn.org/stable/modules/grid_search.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "In this section, we have begun to explore the concept of model validation and hyperparameter optimization, focusing on intuitive aspects of the bias–variance trade-off and how it comes into play when fitting models to data.\n",
    "In particular, we found that the use of a validation set or cross-validation approach is *vital* when tuning parameters in order to avoid over-fitting for more complex/flexible models.\n",
    "\n",
    "In later sections, we will discuss the details of particularly useful models, and throughout will talk about what tuning is available for these models and how these free parameters affect model complexity.\n",
    "Keep the lessons of this section in mind as you read on and learn about these machine learning approaches!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Introducing Scikit-Learn](05.02-Introducing-Scikit-Learn.ipynb) | [Contents](Index.ipynb) | [Feature Engineering](05.04-Feature-Engineering.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/05.03-Hyperparameters-and-Model-Validation.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
